<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Should</name>
    </assembly>
    <members>
        <member name="M:Should.ActionAssertionExtensions.ShouldThrow``1(System.Action)">
            <summary>Verifies that the <paramref name="action"/> throws the specified exception type.</summary>
            <typeparam name="T">The type of exception expected to be thrown.</typeparam>
            <param name="action">The action which should throw the exception.</param>
        </member>
        <member name="M:Should.ActionAssertionExtensions.ShouldThrow``1(Should.Core.Assertions.Assert.ThrowsDelegate)">
            <summary>Verifies that the <paramref name="@delegate"/> throws the specified exception type.</summary>
            <typeparam name="T">The type of exception expected to be thrown.</typeparam>
            <param name="delegate">A <see cref="T:Should.Core.Assertions.Assert.ThrowsDelegate"/> which represents the action which should throw the exception.</param>
        </member>
        <member name="T:Should.BooleanAssertionExtensions">
            <summary>
            Extensions which provide assertions to classes derived from <see cref="T:System.Boolean"/>.
            </summary>
        </member>
        <member name="M:Should.BooleanAssertionExtensions.ShouldBeFalse(System.Boolean)">
            <summary>
            Verifies that the condition is false.
            </summary>
            <param name="condition">The condition to be tested</param>
            <exception cref="T:Should.Core.Exceptions.FalseException">Thrown if the condition is not false</exception>
        </member>
        <member name="M:Should.BooleanAssertionExtensions.ShouldBeFalse(System.Boolean,System.String)">
            <summary>
            Verifies that the condition is false.
            </summary>
            <param name="condition">The condition to be tested</param>
            <param name="userMessage">The message to show when the condition is not false</param>
            <exception cref="T:Should.Core.Exceptions.FalseException">Thrown if the condition is not false</exception>
        </member>
        <member name="M:Should.BooleanAssertionExtensions.ShouldBeTrue(System.Boolean)">
            <summary>
            Verifies that an expression is true.
            </summary>
            <param name="condition">The condition to be inspected</param>
            <exception cref="T:Should.Core.Exceptions.TrueException">Thrown when the condition is false</exception>
        </member>
        <member name="M:Should.BooleanAssertionExtensions.ShouldBeTrue(System.Boolean,System.String)">
            <summary>
            Verifies that an expression is true.
            </summary>
            <param name="condition">The condition to be inspected</param>
            <param name="userMessage">The message to be shown when the condition is false</param>
            <exception cref="T:Should.Core.Exceptions.TrueException">Thrown when the condition is false</exception>
        </member>
        <member name="T:Should.CollectionAssertExtensions">
            <summary>
            Extensions which provide assertions to classes derived from <see cref="T:System.Collections.IEnumerable"/> and <see cref="T:System.Collections.Generic.IEnumerable`1"/>.
            </summary>
        </member>
        <member name="M:Should.CollectionAssertExtensions.ShouldBeEmpty(System.Collections.IEnumerable)">
            <summary>
            Verifies that a collection is empty.
            </summary>
            <param name="collection">The collection to be inspected</param>
            <exception cref="T:System.ArgumentNullException">Thrown when the collection is null</exception>
            <exception cref="T:Should.Core.Exceptions.EmptyException">Thrown when the collection is not empty</exception>
        </member>
        <member name="M:Should.CollectionAssertExtensions.ShouldContain``1(System.Collections.Generic.IEnumerable{``0},``0)">
            <summary>
            Verifies that a collection contains a given object.
            </summary>
            <typeparam name="T">The type of the object to be verified</typeparam>
            <param name="collection">The collection to be inspected</param>
            <param name="expected">The object expected to be in the collection</param>
            <exception cref="T:Should.Core.Exceptions.ContainsException">Thrown when the object is not present in the collection</exception>
        </member>
        <member name="M:Should.CollectionAssertExtensions.ShouldContain``1(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Verifies that a collection contains a given object, using a comparer.
            </summary>
            <typeparam name="T">The type of the object to be verified</typeparam>
            <param name="collection">The collection to be inspected</param>
            <param name="expected">The object expected to be in the collection</param>
            <param name="comparer">The comparer used to equate objects in the collection with the expected object</param>
            <exception cref="T:Should.Core.Exceptions.ContainsException">Thrown when the object is not present in the collection</exception>
        </member>
        <member name="M:Should.CollectionAssertExtensions.ShouldNotBeEmpty(System.Collections.IEnumerable)">
            <summary>
            Verifies that a collection is not empty.
            </summary>
            <param name="collection">The collection to be inspected</param>
            <exception cref="T:System.ArgumentNullException">Thrown when a null collection is passed</exception>
            <exception cref="T:Should.Core.Exceptions.NotEmptyException">Thrown when the collection is empty</exception>
        </member>
        <member name="M:Should.CollectionAssertExtensions.ShouldNotContain``1(System.Collections.Generic.IEnumerable{``0},``0)">
            <summary>
            Verifies that a collection does not contain a given object.
            </summary>
            <typeparam name="T">The type of the object to be compared</typeparam>
            <param name="expected">The object that is expected not to be in the collection</param>
            <param name="collection">The collection to be inspected</param>
            <exception cref="T:Should.Core.Exceptions.DoesNotContainException">Thrown when the object is present inside the container</exception>
        </member>
        <member name="M:Should.CollectionAssertExtensions.ShouldNotContain``1(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Verifies that a collection does not contain a given object, using a comparer.
            </summary>
            <typeparam name="T">The type of the object to be compared</typeparam>
            <param name="expected">The object that is expected not to be in the collection</param>
            <param name="collection">The collection to be inspected</param>
            <param name="comparer">The comparer used to equate objects in the collection with the expected object</param>
            <exception cref="T:Should.Core.Exceptions.DoesNotContainException">Thrown when the object is present inside the container</exception>
        </member>
        <member name="T:Should.Core.Assertions.Assert">
            <summary>
            Contains various static methods that are used to verify that conditions are met during the
            process of running tests.
            </summary>
        </member>
        <member name="M:Should.Core.Assertions.Assert.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Should.Core.Assertions.Assert"/> class.
            </summary>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Contains``1(``0,System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Verifies that a collection contains a given object.
            </summary>
            <typeparam name="T">The type of the object to be verified</typeparam>
            <param name="expected">The object expected to be in the collection</param>
            <param name="collection">The collection to be inspected</param>
            <exception cref="T:Should.Core.Exceptions.ContainsException">Thrown when the object is not present in the collection</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Contains``1(``0,System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Verifies that a collection contains a given object, using an equality comparer.
            </summary>
            <typeparam name="T">The type of the object to be verified</typeparam>
            <param name="expected">The object expected to be in the collection</param>
            <param name="collection">The collection to be inspected</param>
            <param name="comparer">The comparer used to equate objects in the collection with the expected object</param>
            <exception cref="T:Should.Core.Exceptions.ContainsException">Thrown when the object is not present in the collection</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Contains(System.String,System.String)">
            <summary>
            Verifies that a string contains a given sub-string, using the current culture.
            </summary>
            <param name="expectedSubString">The sub-string expected to be in the string</param>
            <param name="actualString">The string to be inspected</param>
            <exception cref="T:Should.Core.Exceptions.ContainsException">Thrown when the sub-string is not present inside the string</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Contains(System.String,System.String,System.StringComparison)">
            <summary>
            Verifies that a string contains a given sub-string, using the given comparison type.
            </summary>
            <param name="expectedSubString">The sub-string expected to be in the string</param>
            <param name="actualString">The string to be inspected</param>
            <param name="comparisonType">The type of string comparison to perform</param>
            <exception cref="T:Should.Core.Exceptions.ContainsException">Thrown when the sub-string is not present inside the string</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.StartsWith(System.String,System.String)">
            <summary>
            
            </summary>
            <param name="expectedStartString"></param>
            <param name="actualString"></param>
            <exception cref="T:Should.Core.Exceptions.StartsWithException">Thrown when the sub-string is not present at the start of the string</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.DoesNotContain``1(``0,System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Verifies that a collection does not contain a given object.
            </summary>
            <typeparam name="T">The type of the object to be compared</typeparam>
            <param name="expected">The object that is expected not to be in the collection</param>
            <param name="collection">The collection to be inspected</param>
            <exception cref="T:Should.Core.Exceptions.DoesNotContainException">Thrown when the object is present inside the container</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.DoesNotContain``1(``0,System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Verifies that a collection does not contain a given object, using an equality comparer.
            </summary>
            <typeparam name="T">The type of the object to be compared</typeparam>
            <param name="expected">The object that is expected not to be in the collection</param>
            <param name="collection">The collection to be inspected</param>
            <param name="comparer">The comparer used to equate objects in the collection with the expected object</param>
            <exception cref="T:Should.Core.Exceptions.DoesNotContainException">Thrown when the object is present inside the container</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.DoesNotContain(System.String,System.String)">
            <summary>
            Verifies that a string does not contain a given sub-string, using the current culture.
            </summary>
            <param name="expectedSubString">The sub-string which is expected not to be in the string</param>
            <param name="actualString">The string to be inspected</param>
            <exception cref="T:Should.Core.Exceptions.DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.DoesNotContain(System.String,System.String,System.StringComparison)">
            <summary>
            Verifies that a string does not contain a given sub-string, using the current culture.
            </summary>
            <param name="expectedSubString">The sub-string which is expected not to be in the string</param>
            <param name="actualString">The string to be inspected</param>
            <param name="comparisonType">The type of string comparison to perform</param>
            <exception cref="T:Should.Core.Exceptions.DoesNotContainException">Thrown when the sub-string is present inside the given string</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Empty(System.Collections.IEnumerable)">
            <summary>
            Verifies that a collection is empty.
            </summary>
            <param name="collection">The collection to be inspected</param>
            <exception cref="T:System.ArgumentNullException">Thrown when the collection is null</exception>
            <exception cref="T:Should.Core.Exceptions.EmptyException">Thrown when the collection is not empty</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Equal``1(``0,``0)">
            <summary>
            Verifies that two objects are equal, using a default comparer.
            </summary>
            <typeparam name="T">The type of the objects to be compared</typeparam>
            <param name="expected">The expected value</param>
            <param name="actual">The value to be compared against</param>
            <exception cref="T:Should.Core.Exceptions.EqualException">Thrown when the objects are not equal</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Equal``1(``0,``0,System.String)">
            <summary>
            Verifies that two objects are equal, using a default comparer.
            </summary>
            <typeparam name="T">The type of the objects to be compared</typeparam>
            <param name="expected">The expected value</param>
            <param name="actual">The value to be compared against</param>
            <param name="userMessage">The user message to be shown on failure</param>
            <exception cref="T:Should.Core.Exceptions.EqualException">Thrown when the objects are not equal</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Equal``1(``0,``0,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Verifies that two objects are equal, using a custom comparer.
            </summary>
            <typeparam name="T">The type of the objects to be compared</typeparam>
            <param name="expected">The expected value</param>
            <param name="actual">The value to be compared against</param>
            <param name="comparer">The comparer used to compare the two objects</param>
            <exception cref="T:Should.Core.Exceptions.EqualException">Thrown when the objects are not equal</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Equal``1(``0,``0,System.Collections.Generic.IEqualityComparer{``0},System.String)">
            <summary>
            Verifies that two objects are equal, using a custom comparer.
            </summary>
            <typeparam name="T">The type of the objects to be compared</typeparam>
            <param name="expected">The expected value</param>
            <param name="actual">The value to be compared against</param>
            <param name="comparer">The comparer used to compare the two objects</param>
            <exception cref="T:Should.Core.Exceptions.EqualException">Thrown when the objects are not equal</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Equal(System.Double,System.Double,System.Double)">
            <summary>
            Verifies that two doubles are equal within a tolerance range.
            </summary>
            <param name="expected">The expected value</param>
            <param name="actual">The value to compare against</param>
            <param name="tolerance">The +/- value for where the expected and actual are considered to be equal</param>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Equal(System.Double,System.Double,System.Double,System.String)">
            <summary>
            Verifies that two doubles are equal within a tolerance range.
            </summary>
            <param name="expected">The expected value</param>
            <param name="actual">The value to compare against</param>
            <param name="tolerance">The +/- value for where the expected and actual are considered to be equal</param>
            <param name="userMessage">The user message to be shown on failure</param>
        </member>
        <member name="M:Should.Core.Assertions.Assert.NotEqual(System.Double,System.Double,System.Double)">
            <summary>
            Verifies that two values are not equal, using a default comparer.
            </summary>
            <param name="expected">The expected value</param>
            <param name="actual">The actual value</param>
            <param name="tolerance">The +/- value for where the expected and actual are considered to be equal</param>
            <exception cref="T:Should.Core.Exceptions.NotEqualException">Thrown when the objects are equal</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.NotEqual(System.Double,System.Double,System.Double,System.String)">
            <summary>
            Verifies that two values are not equal, using a default comparer.
            </summary>
            <param name="expected">The expected value</param>
            <param name="actual">The actual value</param>
            <param name="tolerance">The +/- value for where the expected and actual are considered to be equal</param>
            <param name="userMessage">The user message to be shown on failure</param>
            <exception cref="T:Should.Core.Exceptions.NotEqualException">Thrown when the objects are equal</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Equal(System.DateTime,System.DateTime,System.TimeSpan)">
            <summary>
            Verifies that two dates are equal within a tolerance range.
            </summary>
            <param name="expected">The expected value</param>
            <param name="actual">The value to compare against</param>
            <param name="tolerance">The +/- value for where the expected and actual are considered to be equal</param>
        </member>
        <member name="M:Should.Core.Assertions.Assert.NotEqual(System.DateTime,System.DateTime,System.TimeSpan)">
            <summary>
            Verifies that two dates are not equal within a tolerance range.
            </summary>
            <param name="expected">The expected value</param>
            <param name="actual">The value to compare against</param>
            <param name="tolerance">The +/- value for where the expected and actual are considered to be equal</param>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Equal(System.DateTime,System.DateTime,Should.Core.DatePrecision)">
            <summary>
            Verifies that two dates are equal within a tolerance range.
            </summary>
            <param name="expected">The expected value</param>
            <param name="actual">The value to compare against</param>
            <param name="precision">The level of precision to use when making the comparison</param>
        </member>
        <member name="M:Should.Core.Assertions.Assert.NotEqual(System.DateTime,System.DateTime,Should.Core.DatePrecision)">
            <summary>
            Verifies that two doubles are not equal within a tolerance range.
            </summary>
            <param name="expected">The expected value</param>
            <param name="actual">The value to compare against</param>
            <param name="precision">The level of precision to use when making the comparison</param>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Equals(System.Object,System.Object)">
            <summary>Do not call this method.</summary>
        </member>
        <member name="M:Should.Core.Assertions.Assert.False(System.Boolean)">
            <summary>
            Verifies that the condition is false.
            </summary>
            <param name="condition">The condition to be tested</param>
            <exception cref="T:Should.Core.Exceptions.FalseException">Thrown if the condition is not false</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.False(System.Boolean,System.String)">
            <summary>
            Verifies that the condition is false.
            </summary>
            <param name="condition">The condition to be tested</param>
            <param name="userMessage">The message to show when the condition is not false</param>
            <exception cref="T:Should.Core.Exceptions.FalseException">Thrown if the condition is not false</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.GreaterThan``1(``0,``0)">
            <summary>Verifies that an object is greater than the exclusive minimum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="left">The object to be evaluated.</param>
            <param name="right">An object representing the exclusive minimum value of paramref name="value"/>.</param>
        </member>
        <member name="M:Should.Core.Assertions.Assert.GreaterThan``1(``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>Verifies that an object is greater than the exclusive minimum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="left">The object to be evaluated.</param>
            <param name="right">An object representing the exclusive minimum value of paramref name="value"/&gt;.</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> used to compare the objects.</param>
        </member>
        <member name="M:Should.Core.Assertions.Assert.GreaterThanOrEqual``1(``0,``0)">
            <summary>Verifies that an object is greater than the inclusive minimum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="left">The object to be evaluated.</param>
            <param name="right">An object representing the inclusive minimum value of paramref name="value"/>.</param>
        </member>
        <member name="M:Should.Core.Assertions.Assert.GreaterThanOrEqual``1(``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>Verifies that an object is greater than the inclusive minimum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="left">The object to be evaluated.</param>
            <param name="right">An object representing the inclusive minimum value of paramref name="value"/&gt;.</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> used to compare the objects.</param>
        </member>
        <member name="M:Should.Core.Assertions.Assert.InRange``1(``0,``0,``0)">
            <summary>
            Verifies that a value is within a given range.
            </summary>
            <typeparam name="T">The type of the value to be compared</typeparam>
            <param name="actual">The actual value to be evaluated</param>
            <param name="low">The (inclusive) low value of the range</param>
            <param name="high">The (inclusive) high value of the range</param>
            <exception cref="T:Should.Core.Exceptions.InRangeException">Thrown when the value is not in the given range</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.InRange``1(``0,``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>
            Verifies that a value is within a given range, using a comparer.
            </summary>
            <typeparam name="T">The type of the value to be compared</typeparam>
            <param name="actual">The actual value to be evaluated</param>
            <param name="low">The (inclusive) low value of the range</param>
            <param name="high">The (inclusive) high value of the range</param>
            <param name="comparer">The comparer used to evaluate the value's range</param>
            <exception cref="T:Should.Core.Exceptions.InRangeException">Thrown when the value is not in the given range</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.IsAssignableFrom``1(System.Object)">
            <summary>
            Verifies that an object is of the given type or a derived type.
            </summary>
            <typeparam name="T">The type the object should be</typeparam>
            <param name="object">The object to be evaluated</param>
            <returns>The object, casted to type T when successful</returns>
            <exception cref="T:Should.Core.Exceptions.IsAssignableFromException">Thrown when the object is not the given type</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.IsAssignableFrom(System.Type,System.Object)">
            <summary>
            Verifies that an object is of the given type or a derived type.
            </summary>
            <param name="expectedType">The type the object should be</param>
            <param name="object">The object to be evaluated</param>
            <exception cref="T:Should.Core.Exceptions.IsAssignableFromException">Thrown when the object is not the given type</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.IsAssignableFrom``1(System.Object,System.String)">
            <summary>
            Verifies that an object is of the given type or a derived type.
            </summary>
            <typeparam name="T">The type the object should be</typeparam>
            <param name="object">The object to be evaluated</param>
            <param name="userMessage">The user message to show on failure</param>
            <returns>The object, casted to type T when successful</returns>
            <exception cref="T:Should.Core.Exceptions.IsAssignableFromException">Thrown when the object is not the given type</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.IsAssignableFrom(System.Type,System.Object,System.String)">
            <summary>
            Verifies that an object is of the given type or a derived type.
            </summary>
            <param name="expectedType">The type the object should be</param>
            <param name="userMessage">The user message to show on failure</param>
            <param name="object">The object to be evaluated</param>
            <exception cref="T:Should.Core.Exceptions.IsAssignableFromException">Thrown when the object is not the given type</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.IsNotType``1(System.Object)">
            <summary>        
            Verifies that an object is not exactly the given type.
            </summary>
            <typeparam name="T">The type the object should not be</typeparam>
            <param name="object">The object to be evaluated</param>
            <exception cref="T:Should.Core.Exceptions.IsNotTypeException">Thrown when the object is the given type</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.IsNotType(System.Type,System.Object)">
            <summary>
            Verifies that an object is not exactly the given type.
            </summary>
            <param name="expectedType">The type the object should not be</param>
            <param name="object">The object to be evaluated</param>
            <exception cref="T:Should.Core.Exceptions.IsNotTypeException">Thrown when the object is the given type</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.IsType``1(System.Object)">
            <summary>
            Verifies that an object is exactly the given type (and not a derived type).
            </summary>
            <typeparam name="T">The type the object should be</typeparam>
            <param name="object">The object to be evaluated</param>
            <returns>The object, casted to type T when successful</returns>
            <exception cref="T:Should.Core.Exceptions.IsTypeException">Thrown when the object is not the given type</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.IsType(System.Type,System.Object)">
            <summary>
            Verifies that an object is exactly the given type (and not a derived type).
            </summary>
            <param name="expectedType">The type the object should be</param>
            <param name="object">The object to be evaluated</param>
            <exception cref="T:Should.Core.Exceptions.IsTypeException">Thrown when the object is not the given type</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.LessThan``1(``0,``0)">
            <summary>Verifies that an object is less than the exclusive maximum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="left">The object to be evaluated.</param>
            <param name="right">An object representing the exclusive maximum value of paramref name="value"/>.</param>
        </member>
        <member name="M:Should.Core.Assertions.Assert.LessThan``1(``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>Verifies that an object is less than the exclusive maximum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="left">The object to be evaluated.</param>
            <param name="right">An object representing the exclusive maximum value of paramref name="value"/&gt;.</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> used to compare the objects.</param>
        </member>
        <member name="M:Should.Core.Assertions.Assert.LessThanOrEqual``1(``0,``0)">
            <summary>Verifies that an object is less than the inclusive maximum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="left">The object to be evaluated.</param>
            <param name="right">An object representing the inclusive maximum value of paramref name="value"/>.</param>
        </member>
        <member name="M:Should.Core.Assertions.Assert.LessThanOrEqual``1(``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>Verifies that an object is less than the inclusive maximum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="left">The object to be evaluated.</param>
            <param name="right">An object representing the inclusive maximum value of paramref name="value"/&gt;.</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> used to compare the objects.</param>
        </member>
        <member name="M:Should.Core.Assertions.Assert.NotEmpty(System.Collections.IEnumerable)">
            <summary>
            Verifies that a collection is not empty.
            </summary>
            <param name="collection">The collection to be inspected</param>
            <exception cref="T:System.ArgumentNullException">Thrown when a null collection is passed</exception>
            <exception cref="T:Should.Core.Exceptions.NotEmptyException">Thrown when the collection is empty</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.NotEqual``1(``0,``0)">
            <summary>
            Verifies that two objects are not equal, using a default comparer.
            </summary>
            <typeparam name="T">The type of the objects to be compared</typeparam>
            <param name="expected">The expected object</param>
            <param name="actual">The actual object</param>
            <exception cref="T:Should.Core.Exceptions.NotEqualException">Thrown when the objects are equal</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.NotEqual``1(``0,``0,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Verifies that two objects are not equal, using a custom comparer.
            </summary>
            <typeparam name="T">The type of the objects to be compared</typeparam>
            <param name="expected">The expected object</param>
            <param name="actual">The actual object</param>
            <param name="comparer">The comparer used to examine the objects</param>
            <exception cref="T:Should.Core.Exceptions.NotEqualException">Thrown when the objects are equal</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.NotInRange``1(``0,``0,``0)">
            <summary>
            Verifies that a value is not within a given range, using the default comparer.
            </summary>
            <typeparam name="T">The type of the value to be compared</typeparam>
            <param name="actual">The actual value to be evaluated</param>
            <param name="low">The (inclusive) low value of the range</param>
            <param name="high">The (inclusive) high value of the range</param>
            <exception cref="T:Should.Core.Exceptions.NotInRangeException">Thrown when the value is in the given range</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.NotInRange``1(``0,``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>
            Verifies that a value is not within a given range, using a comparer.
            </summary>
            <typeparam name="T">The type of the value to be compared</typeparam>
            <param name="actual">The actual value to be evaluated</param>
            <param name="low">The (inclusive) low value of the range</param>
            <param name="high">The (inclusive) high value of the range</param>
            <param name="comparer">The comparer used to evaluate the value's range</param>
            <exception cref="T:Should.Core.Exceptions.NotInRangeException">Thrown when the value is in the given range</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.NotNull(System.Object)">
            <summary>
            Verifies that an object reference is not null.
            </summary>
            <param name="object">The object to be validated</param>
            <exception cref="T:Should.Core.Exceptions.NotNullException">Thrown when the object is not null</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.NotNull(System.Object,System.String)">
            <summary>
            Verifies that an object reference is not null.
            </summary>
            <param name="object">The object to be validated</param>
            <exception cref="T:Should.Core.Exceptions.NotNullException">Thrown when the object is not null</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.NotSame(System.Object,System.Object)">
            <summary>
            Verifies that two objects are not the same instance.
            </summary>
            <param name="expected">The expected object instance</param>
            <param name="actual">The actual object instance</param>
            <exception cref="T:Should.Core.Exceptions.NotSameException">Thrown when the objects are the same instance</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Null(System.Object)">
            <summary>
            Verifies that an object reference is null.
            </summary>
            <param name="object">The object to be inspected</param>
            <exception cref="T:Should.Core.Exceptions.NullException">Thrown when the object reference is not null</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Same(System.Object,System.Object)">
            <summary>
            Verifies that two objects are the same instance.
            </summary>
            <param name="expected">The expected object instance</param>
            <param name="actual">The actual object instance</param>
            <exception cref="T:Should.Core.Exceptions.SameException">Thrown when the objects are not the same instance</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Single(System.Collections.IEnumerable)">
            <summary>
            Verifies that the given collection contains only a single
            element of the given type.
            </summary>
            <param name="collection">The collection.</param>
            <returns>The single item in the collection.</returns>
            <exception cref="T:Should.Core.Exceptions.SingleException">Thrown when the collection does not contain
            exactly one element.</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Single``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Verifies that the given collection contains only a single
            element of the given type.
            </summary>
            <typeparam name="T">The collection type.</typeparam>
            <param name="collection">The collection.</param>
            <returns>The single item in the collection.</returns>
            <exception cref="T:Should.Core.Exceptions.SingleException">Thrown when the collection does not contain
            exactly one element.</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Throws``1(Should.Core.Assertions.Assert.ThrowsDelegate)">
            <summary>
            Verifies that the exact exception is thrown (and not a derived exception type).
            </summary>
            <typeparam name="T">The type of the exception expected to be thrown</typeparam>
            <param name="testCode">A delegate to the code to be tested</param>
            <returns>The exception that was thrown, when successful</returns>
            <exception cref="T:Should.Core.Exceptions.ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Throws``1(System.String,Should.Core.Assertions.Assert.ThrowsDelegate)">
            <summary>
            Verifies that the exact exception is thrown (and not a derived exception type).
            </summary>
            <typeparam name="T">The type of the exception expected to be thrown</typeparam>
            <param name="userMessage">The message to be shown if the test fails</param>
            <param name="testCode">A delegate to the code to be tested</param>
            <returns>The exception that was thrown, when successful</returns>
            <exception cref="T:Should.Core.Exceptions.ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Throws``1(Should.Core.Assertions.Assert.ThrowsDelegateWithReturn)">
            <summary>
            Verifies that the exact exception is thrown (and not a derived exception type).
            Generally used to test property accessors.
            </summary>
            <typeparam name="T">The type of the exception expected to be thrown</typeparam>
            <param name="testCode">A delegate to the code to be tested</param>
            <returns>The exception that was thrown, when successful</returns>
            <exception cref="T:Should.Core.Exceptions.ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Throws``1(System.String,Should.Core.Assertions.Assert.ThrowsDelegateWithReturn)">
            <summary>
            Verifies that the exact exception is thrown (and not a derived exception type).
            Generally used to test property accessors.
            </summary>
            <typeparam name="T">The type of the exception expected to be thrown</typeparam>
            <param name="userMessage">The message to be shown if the test fails</param>
            <param name="testCode">A delegate to the code to be tested</param>
            <returns>The exception that was thrown, when successful</returns>
            <exception cref="T:Should.Core.Exceptions.ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Throws(System.Type,Should.Core.Assertions.Assert.ThrowsDelegate)">
            <summary>
            Verifies that the exact exception is thrown (and not a derived exception type).
            </summary>
            <param name="exceptionType">The type of the exception expected to be thrown</param>
            <param name="testCode">A delegate to the code to be tested</param>
            <returns>The exception that was thrown, when successful</returns>
            <exception cref="T:Should.Core.Exceptions.ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.Throws(System.Type,Should.Core.Assertions.Assert.ThrowsDelegateWithReturn)">
            <summary>
            Verifies that the exact exception is thrown (and not a derived exception type).
            Generally used to test property accessors.
            </summary>
            <param name="exceptionType">The type of the exception expected to be thrown</param>
            <param name="testCode">A delegate to the code to be tested</param>
            <returns>The exception that was thrown, when successful</returns>
            <exception cref="T:Should.Core.Exceptions.ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.DoesNotThrow(Should.Core.Assertions.Assert.ThrowsDelegate)">
            <summary>
            Verifies that a block of code does not throw any exceptions.
            </summary>
            <param name="testCode">A delegate to the code to be tested</param>
        </member>
        <member name="M:Should.Core.Assertions.Assert.True(System.Boolean)">
            <summary>
            Verifies that an expression is true.
            </summary>
            <param name="condition">The condition to be inspected</param>
            <exception cref="T:Should.Core.Exceptions.TrueException">Thrown when the condition is false</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assert.True(System.Boolean,System.String)">
            <summary>
            Verifies that an expression is true.
            </summary>
            <param name="condition">The condition to be inspected</param>
            <param name="userMessage">The message to be shown when the condition is false</param>
            <exception cref="T:Should.Core.Exceptions.TrueException">Thrown when the condition is false</exception>
        </member>
        <member name="T:Should.Core.Assertions.Assert.ThrowsDelegate">
            <summary>
            Used by the Throws and DoesNotThrow methods.
            </summary>
        </member>
        <member name="T:Should.Core.Assertions.Assert.ThrowsDelegateWithReturn">
            <summary>
            Used by the Throws and DoesNotThrow methods.
            </summary>
        </member>
        <member name="T:Should.Core.Assertions.Assertions">
            <summary>
            A wrapper for Assert which is used by <see cref="!:TestClass"/>.
            </summary>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.Contains``1(``0,System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Verifies that a collection contains a given object.
            </summary>
            <typeparam name="T">The type of the object to be verified</typeparam>
            <param name="expected">The object expected to be in the collection</param>
            <param name="collection">The collection to be inspected</param>
            <exception cref="T:Should.Core.Exceptions.ContainsException">Thrown when the object is not present in the collection</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.Contains``1(``0,System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Verifies that a collection contains a given object, using a comparer.
            </summary>
            <typeparam name="T">The type of the object to be verified</typeparam>
            <param name="expected">The object expected to be in the collection</param>
            <param name="collection">The collection to be inspected</param>
            <param name="comparer">The comparer used to equate objects in the collection with the expected object</param>
            <exception cref="T:Should.Core.Exceptions.ContainsException">Thrown when the object is not present in the collection</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.Contains(System.String,System.String)">
            <summary>
            Verifies that a string contains a given sub-string, using the current culture.
            </summary>
            <param name="expectedSubString">The sub-string expected to be in the string</param>
            <param name="actualString">The string to be inspected</param>
            <exception cref="T:Should.Core.Exceptions.ContainsException">Thrown when the sub-string is not present inside the string</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.Contains(System.String,System.String,System.StringComparison)">
            <summary>
            Verifies that a string contains a given sub-string, using the given comparison type.
            </summary>
            <param name="expectedSubString">The sub-string expected to be in the string</param>
            <param name="actualString">The string to be inspected</param>
            <param name="comparisonType">The type of string comparison to perform</param>
            <exception cref="T:Should.Core.Exceptions.ContainsException">Thrown when the sub-string is not present inside the string</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.DoesNotContain``1(``0,System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Verifies that a collection does not contain a given object.
            </summary>
            <typeparam name="T">The type of the object to be compared</typeparam>
            <param name="expected">The object that is expected not to be in the collection</param>
            <param name="collection">The collection to be inspected</param>
            <exception cref="T:Should.Core.Exceptions.DoesNotContainException">Thrown when the object is present inside the container</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.DoesNotContain``1(``0,System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Verifies that a collection does not contain a given object, using a comparer.
            </summary>
            <typeparam name="T">The type of the object to be compared</typeparam>
            <param name="expected">The object that is expected not to be in the collection</param>
            <param name="collection">The collection to be inspected</param>
            <param name="comparer">The comparer used to equate objects in the collection with the expected object</param>
            <exception cref="T:Should.Core.Exceptions.DoesNotContainException">Thrown when the object is present inside the container</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.DoesNotContain(System.String,System.String)">
            <summary>
            Verifies that a string does not contain a given sub-string, using the current culture.
            </summary>
            <param name="expectedSubString">The sub-string which is expected not to be in the string</param>
            <param name="actualString">The string to be inspected</param>
            <exception cref="T:Should.Core.Exceptions.DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.DoesNotContain(System.String,System.String,System.StringComparison)">
            <summary>
            Verifies that a string does not contain a given sub-string, using the current culture.
            </summary>
            <param name="expectedSubString">The sub-string which is expected not to be in the string</param>
            <param name="actualString">The string to be inspected</param>
            <param name="comparisonType">The type of string comparison to perform</param>
            <exception cref="T:Should.Core.Exceptions.DoesNotContainException">Thrown when the sub-string is present inside the given string</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.Empty(System.Collections.IEnumerable)">
            <summary>
            Verifies that a collection is empty.
            </summary>
            <param name="collection">The collection to be inspected</param>
            <exception cref="T:System.ArgumentNullException">Thrown when the collection is null</exception>
            <exception cref="T:Should.Core.Exceptions.EmptyException">Thrown when the collection is not empty</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.Equal``1(``0,``0)">
            <summary>
            Verifies that two objects are equal, using a default comparer.
            </summary>
            <typeparam name="T">The type of the objects to be compared</typeparam>
            <param name="expected">The expected value</param>
            <param name="actual">The value to be compared against</param>
            <exception cref="T:Should.Core.Exceptions.EqualException">Thrown when the objects are not equal</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.Equal``1(``0,``0,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Verifies that two objects are equal, using a custom comparer.
            </summary>
            <typeparam name="T">The type of the objects to be compared</typeparam>
            <param name="expected">The expected value</param>
            <param name="actual">The value to be compared against</param>
            <param name="comparer">The comparer used to compare the two objects</param>
            <exception cref="T:Should.Core.Exceptions.EqualException">Thrown when the objects are not equal</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.Equals(System.Object)">
            <summary>Do not call this method. Call Assert.Equal() instead.</summary>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.False(System.Boolean)">
            <summary>
            Verifies that the condition is false.
            </summary>
            <param name="condition">The condition to be tested</param>
            <exception cref="T:Should.Core.Exceptions.FalseException">Thrown if the condition is not false</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.False(System.Boolean,System.String)">
            <summary>
            Verifies that the condition is false.
            </summary>
            <param name="condition">The condition to be tested</param>
            <param name="userMessage">The message to show when the condition is not false</param>
            <exception cref="T:Should.Core.Exceptions.FalseException">Thrown if the condition is not false</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.GetHashCode">
            <summary>
            Serves as a hash function for a particular type.
            </summary>
            <returns>A hash code for the current <see cref="T:System.Object"/>.</returns>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.GreaterThan``1(``0,``0)">
            <summary>Verifies that an object is greater than the exclusive minimum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="value">The object to be evaluated.</param>
            <param name="maxValue">An object representing the exclusive minimum value of paramref name="value"/>.</param>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.GreaterThan``1(``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>Verifies that an object is greater than the exclusive minimum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="value">The object to be evaluated.</param>
            <param name="minValue">An object representing the exclusive minimum value of paramref name="value"/&gt;.</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> used to compare the objects.</param>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.GreaterThanOrEqual``1(``0,``0)">
            <summary>Verifies that an object is greater than the inclusive minimum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="value">The object to be evaluated.</param>
            <param name="minValue">An object representing the inclusive minimum value of paramref name="value"/>.</param>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.GreaterThanOrEqual``1(``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>Verifies that an object is greater than the inclusive minimum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="value">The object to be evaluated.</param>
            <param name="minValue">An object representing the inclusive minimum value of paramref name="value"/&gt;.</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> used to compare the objects.</param>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.InRange``1(``0,``0,``0)">
            <summary>
            Verifies that a value is within a given range.
            </summary>
            <typeparam name="T">The type of the value to be compared</typeparam>
            <param name="actual">The actual value to be evaluated</param>
            <param name="low">The (inclusive) low value of the range</param>
            <param name="high">The (inclusive) high value of the range</param>
            <exception cref="T:Should.Core.Exceptions.InRangeException">Thrown when the value is not in the given range</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.InRange``1(``0,``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>
            Verifies that a value is within a given range, using a comparer.
            </summary>
            <typeparam name="T">The type of the value to be compared</typeparam>
            <param name="actual">The actual value to be evaluated</param>
            <param name="low">The (inclusive) low value of the range</param>
            <param name="high">The (inclusive) high value of the range</param>
            <param name="comparer">The comparer used to evaluate the value's range</param>
            <exception cref="T:Should.Core.Exceptions.InRangeException">Thrown when the value is not in the given range</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.IsNotType``1(System.Object)">
            <summary>
            Verifies that an object is not exactly the given type.
            </summary>
            <typeparam name="T">The type the object should not be</typeparam>
            <param name="object">The object to be evaluated</param>
            <exception cref="T:Should.Core.Exceptions.IsTypeException">Thrown when the object is the given type</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.IsNotType(System.Type,System.Object)">
            <summary>
            Verifies that an object is not exactly the given type.
            </summary>
            <param name="expectedType">The type the object should not be</param>
            <param name="object">The object to be evaluated</param>
            <exception cref="T:Should.Core.Exceptions.IsTypeException">Thrown when the object is the given type</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.IsType``1(System.Object)">
            <summary>
            Verifies that an object is exactly the given type (and not a derived type).
            </summary>
            <typeparam name="T">The type the object should be</typeparam>
            <param name="object">The object to be evaluated</param>
            <returns>The object, casted to type T when successful</returns>
            <exception cref="T:Should.Core.Exceptions.IsTypeException">Thrown when the object is not the given type</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.IsType(System.Type,System.Object)">
            <summary>
            Verifies that an object is exactly the given type (and not a derived type).
            </summary>
            <param name="expectedType">The type the object should be</param>
            <param name="object">The object to be evaluated</param>
            <exception cref="T:Should.Core.Exceptions.IsTypeException">Thrown when the object is not the given type</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.LessThan``1(``0,``0)">
            <summary>Verifies that an object is less than the exclusive maximum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="value">The object to be evaluated.</param>
            <param name="maxValue">An object representing the exclusive maximum value of paramref name="value"/>.</param>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.LessThan``1(``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>Verifies that an object is less than the exclusive maximum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="value">The object to be evaluated.</param>
            <param name="maxValue">An object representing the exclusive maximum value of paramref name="value"/&gt;.</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> used to compare the objects.</param>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.LessThanOrEqual``1(``0,``0)">
            <summary>Verifies that an object is less than the inclusive maximum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="value">The object to be evaluated.</param>
            <param name="maxValue">An object representing the inclusive maximum value of paramref name="value"/>.</param>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.LessThanOrEqual``1(``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>Verifies that an object is less than the inclusive maximum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="value">The object to be evaluated.</param>
            <param name="maxValue">An object representing the inclusive maximum value of paramref name="value"/&gt;.</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> used to compare the objects.</param>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.NotEmpty(System.Collections.IEnumerable)">
            <summary>
            Verifies that a collection is not empty.
            </summary>
            <param name="collection">The collection to be inspected</param>
            <exception cref="T:System.ArgumentNullException">Thrown when a null collection is passed</exception>
            <exception cref="T:Should.Core.Exceptions.NotEmptyException">Thrown when the collection is empty</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.NotEqual``1(``0,``0)">
            <summary>
            Verifies that two objects are not equal, using a default comparer.
            </summary>
            <typeparam name="T">The type of the objects to be compared</typeparam>
            <param name="expected">The expected object</param>
            <param name="actual">The actual object</param>
            <exception cref="T:Should.Core.Exceptions.NotEqualException">Thrown when the objects are equal</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.NotEqual``1(``0,``0,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Verifies that two objects are not equal, using a custom comparer.
            </summary>
            <typeparam name="T">The type of the objects to be compared</typeparam>
            <param name="expected">The expected object</param>
            <param name="actual">The actual object</param>
            <param name="comparer">The comparer used to examine the objects</param>
            <exception cref="T:Should.Core.Exceptions.NotEqualException">Thrown when the objects are equal</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.NotInRange``1(``0,``0,``0)">
            <summary>
            Verifies that a value is not within a given range, using the default comparer.
            </summary>
            <typeparam name="T">The type of the value to be compared</typeparam>
            <param name="actual">The actual value to be evaluated</param>
            <param name="low">The (inclusive) low value of the range</param>
            <param name="high">The (inclusive) high value of the range</param>
            <exception cref="T:Should.Core.Exceptions.NotInRangeException">Thrown when the value is in the given range</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.NotInRange``1(``0,``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>
            Verifies that a value is not within a given range, using a comparer.
            </summary>
            <typeparam name="T">The type of the value to be compared</typeparam>
            <param name="actual">The actual value to be evaluated</param>
            <param name="low">The (inclusive) low value of the range</param>
            <param name="high">The (inclusive) high value of the range</param>
            <param name="comparer">The comparer used to evaluate the value's range</param>
            <exception cref="T:Should.Core.Exceptions.NotInRangeException">Thrown when the value is in the given range</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.NotNull(System.Object)">
            <summary>
            Verifies that an object reference is not null.
            </summary>
            <param name="object">The object to be validated</param>
            <exception cref="T:Should.Core.Exceptions.NotNullException">Thrown when the object is not null</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.NotSame(System.Object,System.Object)">
            <summary>
            Verifies that two objects are not the same instance.
            </summary>
            <param name="expected">The expected object instance</param>
            <param name="actual">The actual object instance</param>
            <exception cref="T:Should.Core.Exceptions.NotSameException">Thrown when the objects are the same instance</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.Null(System.Object)">
            <summary>
            Verifies that an object reference is null.
            </summary>
            <param name="object">The object to be inspected</param>
            <exception cref="T:Should.Core.Exceptions.NullException">Thrown when the object reference is not null</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.Same(System.Object,System.Object)">
            <summary>
            Verifies that two objects are the same instance.
            </summary>
            <param name="expected">The expected object instance</param>
            <param name="actual">The actual object instance</param>
            <exception cref="T:Should.Core.Exceptions.SameException">Thrown when the objects are not the same instance</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.Throws``1(Should.Core.Assertions.Assert.ThrowsDelegate)">
            <summary>
            Verifies that the exact exception is thrown (and not a derived exception type).
            </summary>
            <typeparam name="T">The type of the exception expected to be thrown</typeparam>
            <param name="testCode">A delegate to the code to be tested</param>
            <returns>The exception that was thrown, when successful</returns>
            <exception cref="T:Should.Core.Exceptions.ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.Throws``1(System.String,Should.Core.Assertions.Assert.ThrowsDelegate)">
            <summary>
            Verifies that the exact exception is thrown (and not a derived exception type).
            </summary>
            <typeparam name="T">The type of the exception expected to be thrown</typeparam>
            <param name="userMessage">The message to be shown if the test fails</param>
            <param name="testCode">A delegate to the code to be tested</param>
            <returns>The exception that was thrown, when successful</returns>
            <exception cref="T:Should.Core.Exceptions.ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.Throws(System.Type,Should.Core.Assertions.Assert.ThrowsDelegate)">
            <summary>
            Verifies that the exact exception is thrown (and not a derived exception type).
            </summary>
            <param name="exceptionType">The type of the exception expected to be thrown</param>
            <param name="testCode">A delegate to the code to be tested</param>
            <returns>The exception that was thrown, when successful</returns>
            <exception cref="T:Should.Core.Exceptions.ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.True(System.Boolean)">
            <summary>
            Verifies that an expression is true.
            </summary>
            <param name="condition">The condition to be inspected</param>
            <exception cref="T:Should.Core.Exceptions.TrueException">Thrown when the condition is false</exception>
        </member>
        <member name="M:Should.Core.Assertions.Assertions.True(System.Boolean,System.String)">
            <summary>
            Verifies that an expression is true.
            </summary>
            <param name="condition">The condition to be inspected</param>
            <param name="userMessage">The message to be shown when the condition is false</param>
            <exception cref="T:Should.Core.Exceptions.TrueException">Thrown when the condition is false</exception>
        </member>
        <member name="T:Should.Core.Assertions.Record">
            <summary>
            Allows the user to record actions for a test.
            </summary>
        </member>
        <member name="M:Should.Core.Assertions.Record.Exception(Should.Core.Assertions.Assert.ThrowsDelegate)">
            <summary>
            Records any exception which is thrown by the given code.
            </summary>
            <param name="code">The code which may thrown an exception.</param>
            <returns>Returns the exception that was thrown by the code; null, otherwise.</returns>
        </member>
        <member name="M:Should.Core.Assertions.Record.Exception(Should.Core.Assertions.Assert.ThrowsDelegateWithReturn)">
            <summary>
            Records any exception which is thrown by the given code that has
            a return value. Generally used for testing property accessors.
            </summary>
            <param name="code">The code which may thrown an exception.</param>
            <returns>Returns the exception that was thrown by the code; null, otherwise.</returns>
        </member>
        <member name="T:Should.Core.Exceptions.AssertActualExpectedException">
            <summary>
            Base class for exceptions that have actual and expected values
            </summary>
        </member>
        <member name="T:Should.Core.Exceptions.AssertException">
            <summary>
            The base assert exception class
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.AssertException.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Should.Core.Exceptions.AssertException"/> class.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.AssertException.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:Should.Core.Exceptions.AssertException"/> class.
            </summary>
            <param name="userMessage">The user message to be displayed</param>
        </member>
        <member name="M:Should.Core.Exceptions.AssertException.#ctor(System.String,System.Exception)">
            <summary>
            Initializes a new instance of the <see cref="T:Should.Core.Exceptions.AssertException"/> class.
            </summary>
            <param name="userMessage">The user message to be displayed</param>
            <param name="innerException">The inner exception</param>
        </member>
        <member name="M:Should.Core.Exceptions.AssertException.#ctor(System.String,System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:Should.Core.Exceptions.AssertException"/> class.
            </summary>
            <param name="userMessage">The user message to be displayed</param>
            <param name="stackTrace">The stack trace to be displayed</param>
        </member>
        <member name="M:Should.Core.Exceptions.AssertException.FilterStackTrace(System.String)">
            <summary>
            Filters the stack trace to remove all lines that occur within the testing framework.
            </summary>
            <param name="stackTrace">The original stack trace</param>
            <returns>The filtered stack trace</returns>
        </member>
        <member name="P:Should.Core.Exceptions.AssertException.StackTrace">
            <summary>
            Gets a string representation of the frames on the call stack at the time the current exception was thrown.
            </summary>
            <returns>A string that describes the contents of the call stack, with the most recent method call appearing first.</returns>
        </member>
        <member name="P:Should.Core.Exceptions.AssertException.UserMessage">
            <summary>
            Gets the user message
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.AssertActualExpectedException.#ctor(System.Object,System.Object,System.String)">
            <summary>
            Creates a new instance of the <see href="AssertActualExpectedException"/> class.
            </summary>
            <param name="expected">The expected value</param>
            <param name="actual">The actual value</param>
            <param name="userMessage">The user message to be shown</param>
        </member>
        <member name="M:Should.Core.Exceptions.AssertActualExpectedException.#ctor(System.Object,System.Object,System.String,System.Boolean)">
            <summary>
            Creates a new instance of the <see href="AssertActualExpectedException"/> class.
            </summary>
            <param name="expected">The expected value</param>
            <param name="actual">The actual value</param>
            <param name="userMessage">The user message to be shown</param>
            <param name="skipPositionCheck">Set to true to skip the check for difference position</param>
        </member>
        <member name="P:Should.Core.Exceptions.AssertActualExpectedException.Actual">
            <summary>
            Gets the actual value.
            </summary>
        </member>
        <member name="P:Should.Core.Exceptions.AssertActualExpectedException.Expected">
            <summary>
            Gets the expected value.
            </summary>
        </member>
        <member name="P:Should.Core.Exceptions.AssertActualExpectedException.Message">
            <summary>
            Gets a message that describes the current exception. Includes the expected and actual values.
            </summary>
            <returns>The error message that explains the reason for the exception, or an empty string("").</returns>
            <filterpriority>1</filterpriority>
        </member>
        <member name="T:Should.Core.Exceptions.ContainsException">
            <summary>
            Exception thrown when a collection unexpectedly does not contain the expected value.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.ContainsException.#ctor(System.Object)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.ContainsException"/> class.
            </summary>
            <param name="expected">The expected object value</param>
        </member>
        <member name="T:Should.Core.Exceptions.DoesNotContainException">
            <summary>
            Exception thrown when a collection unexpectedly contains the expected value.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.DoesNotContainException.#ctor(System.Object)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.DoesNotContainException"/> class.
            </summary>
            <param name="expected">The expected object value</param>
        </member>
        <member name="T:Should.Core.Exceptions.DoesNotThrowException">
            <summary>
            Exception thrown when code unexpectedly throws an exception.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.DoesNotThrowException.#ctor(System.Exception)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.DoesNotThrowException"/> class.
            </summary>
            <param name="actual">Actual exception</param>
        </member>
        <member name="P:Should.Core.Exceptions.DoesNotThrowException.StackTrace">
            <summary>
            Gets a string representation of the frames on the call stack at the time the current exception was thrown.
            </summary>
            <returns>A string that describes the contents of the call stack, with the most recent method call appearing first.</returns>
        </member>
        <member name="T:Should.Core.Exceptions.EmptyException">
            <summary>
            Exception thrown when a collection is unexpectedly not empty.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.EmptyException.#ctor">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.EmptyException"/> class.
            </summary>
        </member>
        <member name="T:Should.Core.Exceptions.EqualException">
            <summary>
            Exception thrown when two values are unexpectedly not equal.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.EqualException.#ctor(System.Object,System.Object)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.EqualException"/> class.
            </summary>
            <param name="expected">The expected object value</param>
            <param name="actual">The actual object value</param>
        </member>
        <member name="M:Should.Core.Exceptions.EqualException.#ctor(System.Object,System.Object,System.String)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.EqualException"/> class.
            </summary>
            <param name="expected">The expected object value</param>
            <param name="actual">The actual object value</param>
            <param name="userMessage">The user message to be shown on failure</param>
        </member>
        <member name="T:Should.Core.Exceptions.FalseException">
            <summary>
            Exception thrown when a value is unexpectedly true.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.FalseException.#ctor(System.String)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.FalseException"/> class.
            </summary>
            <param name="userMessage">The user message to be display, or null for the default message</param>
        </member>
        <member name="T:Should.Core.Exceptions.GreaterThanException">
            <summary>Exception thrown when a value is not greater than the expected minimum.</summary>
        </member>
        <member name="M:Should.Core.Exceptions.GreaterThanException.#ctor(System.Object,System.Object)">
            <summary>Initializes a new instance of the <see cref="T:Should.Core.Exceptions.GreaterThanException"/> class.</summary>
            <param name="left">The value being tested.</param>
            <param name="right">The exclusive minimum allowed value.</param>
        </member>
        <member name="M:Should.Core.Exceptions.GreaterThanException.#ctor(System.Object,System.Object,System.String)">
            <summary>Initializes a new instance of the <see cref="T:Should.Core.Exceptions.GreaterThanException"/> class.</summary>
            <param name="left">The value being tested.</param>
            <param name="right">The exclusive minimum allowed value.</param>
        </member>
        <member name="T:Should.Core.Exceptions.GreaterThanOrEqualException">
            <summary>Exception thrown when a value is not greater than the expected minimum.</summary>
        </member>
        <member name="M:Should.Core.Exceptions.GreaterThanOrEqualException.#ctor(System.Object,System.Object)">
            <summary>Initializes a new instance of the <see cref="T:Should.Core.Exceptions.GreaterThanOrEqualException"/> class.</summary>
            <param name="left">The value being tested.</param>
            <param name="right">The exclusive minimum allowed value.</param>
        </member>
        <member name="M:Should.Core.Exceptions.GreaterThanOrEqualException.#ctor(System.Object,System.Object,System.String)">
            <summary>Initializes a new instance of the <see cref="T:Should.Core.Exceptions.GreaterThanOrEqualException"/> class.</summary>
            <param name="left">The value being tested.</param>
            <param name="right">The exclusive minimum allowed value.</param>
        </member>
        <member name="T:Should.Core.Exceptions.InRangeException">
            <summary>
            Exception thrown when a value is unexpectedly not in the given range.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.InRangeException.#ctor(System.Object,System.Object,System.Object)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.InRangeException"/> class.
            </summary>
            <param name="actual">The actual object value</param>
            <param name="low">The low value of the range</param>
            <param name="high">The high value of the range</param>
        </member>
        <member name="P:Should.Core.Exceptions.InRangeException.Actual">
            <summary>
            Gets the actual object value
            </summary>
        </member>
        <member name="P:Should.Core.Exceptions.InRangeException.High">
            <summary>
            Gets the high value of the range
            </summary>
        </member>
        <member name="P:Should.Core.Exceptions.InRangeException.Low">
            <summary>
            Gets the low value of the range
            </summary>
        </member>
        <member name="P:Should.Core.Exceptions.InRangeException.Message">
            <summary>
            Gets a message that describes the current exception.
            </summary>
            <returns>The error message that explains the reason for the exception, or an empty string("").</returns>
        </member>
        <member name="T:Should.Core.Exceptions.IsAssignableFromException">
            <summary>
            Exception thrown when the value is unexpectedly not of the given type or a derived type.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.IsAssignableFromException.#ctor(System.Type,System.Object)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.IsTypeException"/> class.
            </summary>
            <param name="expected">The expected type</param>
            <param name="actual">The actual object value</param>
        </member>
        <member name="M:Should.Core.Exceptions.IsAssignableFromException.#ctor(System.Type,System.Object,System.String)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.IsTypeException"/> class.
            </summary>
            <param name="expected">The expected type</param>
            <param name="actual">The actual object value</param>
            <param name="userMessage">A custom message to prepend to the default Assert.IsAssignableFrom() failure message</param>
        </member>
        <member name="T:Should.Core.Exceptions.IsNotTypeException">
            <summary>
            Exception thrown when the value is unexpectedly of the exact given type.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.IsNotTypeException.#ctor(System.Type,System.Object)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.IsNotTypeException"/> class.
            </summary>
            <param name="expected">The expected type</param>
            <param name="actual">The actual object value</param>
        </member>
        <member name="T:Should.Core.Exceptions.IsTypeException">
            <summary>
            Exception thrown when the value is unexpectedly not of the exact given type.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.IsTypeException.#ctor(System.Type,System.Object)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.IsTypeException"/> class.
            </summary>
            <param name="expected">The expected type</param>
            <param name="actual">The actual object value</param>
        </member>
        <member name="T:Should.Core.Exceptions.LessThanException">
            <summary>Exception thrown when a value is not less than the expected maximum.</summary>
        </member>
        <member name="M:Should.Core.Exceptions.LessThanException.#ctor(System.Object,System.Object)">
            <summary>Initializes a new instance of the <see cref="T:Should.Core.Exceptions.LessThanException"/> class.</summary>
            <param name="left">The value being tested.</param>
            <param name="right">The exclusive maximum allowed value.</param>
        </member>
        <member name="M:Should.Core.Exceptions.LessThanException.#ctor(System.Object,System.Object,System.String)">
            <summary>Initializes a new instance of the <see cref="T:Should.Core.Exceptions.LessThanException"/> class.</summary>
            <param name="left">The value being tested.</param>
            <param name="right">The exclusive maximum allowed value.</param>
        </member>
        <member name="T:Should.Core.Exceptions.LessThanOrEqualException">
            <summary>Exception thrown when a value is not less than or equal to the expected maximum.</summary>
        </member>
        <member name="M:Should.Core.Exceptions.LessThanOrEqualException.#ctor(System.Object,System.Object)">
            <summary>Initializes a new instance of the <see cref="T:Should.Core.Exceptions.LessThanOrEqualException"/> class.</summary>
            <param name="left">The value being tested.</param>
            <param name="right">The exclusive maximum allowed value.</param>
        </member>
        <member name="M:Should.Core.Exceptions.LessThanOrEqualException.#ctor(System.Object,System.Object,System.String)">
            <summary>Initializes a new instance of the <see cref="T:Should.Core.Exceptions.LessThanOrEqualException"/> class.</summary>
            <param name="left">The value being tested.</param>
            <param name="right">The exclusive maximum allowed value.</param>
        </member>
        <member name="T:Should.Core.Exceptions.NotEmptyException">
            <summary>
            Exception thrown when a collection is unexpectedly empty.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.NotEmptyException.#ctor">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.NotEmptyException"/> class.
            </summary>
        </member>
        <member name="T:Should.Core.Exceptions.NotEqualException">
            <summary>
            Exception thrown when two values are unexpectedly equal.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.NotEqualException.#ctor(System.Object,System.Object)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.NotEqualException"/> class.
            </summary>
            <param name="expected">The expected object value</param>
            <param name="actual">The actual object value</param>
        </member>
        <member name="M:Should.Core.Exceptions.NotEqualException.#ctor(System.Object,System.Object,System.String)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.NotEqualException"/> class.
            </summary>
            <param name="expected">The expected object value</param>
            <param name="actual">The actual object value</param>
            <param name="userMessage">The user message to be shown on failure</param>
        </member>
        <member name="T:Should.Core.Exceptions.NotInRangeException">
            <summary>
            Exception thrown when a value is unexpectedly in the given range.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.NotInRangeException.#ctor(System.Object,System.Object,System.Object)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.NotInRangeException"/> class.
            </summary>
            <param name="actual">The actual object value</param>
            <param name="low">The low value of the range</param>
            <param name="high">The high value of the range</param>
        </member>
        <member name="P:Should.Core.Exceptions.NotInRangeException.Actual">
            <summary>
            Gets the actual object value
            </summary>
        </member>
        <member name="P:Should.Core.Exceptions.NotInRangeException.High">
            <summary>
            Gets the high value of the range
            </summary>
        </member>
        <member name="P:Should.Core.Exceptions.NotInRangeException.Low">
            <summary>
            Gets the low value of the range
            </summary>
        </member>
        <member name="P:Should.Core.Exceptions.NotInRangeException.Message">
            <summary>
            Gets a message that describes the current exception.
            </summary>
            <returns>The error message that explains the reason for the exception, or an empty string("").</returns>
        </member>
        <member name="T:Should.Core.Exceptions.NotNullException">
            <summary>
            Exception thrown when an object is unexpectedly null.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.NotNullException.#ctor">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.NotNullException"/> class.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.NotNullException.#ctor(System.String)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.NotNullException"/> class with the given failure <paramref name="message"/>.
            </summary>
        </member>
        <member name="T:Should.Core.Exceptions.NotSameException">
            <summary>
            Exception thrown when two values are unexpected the same instance.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.NotSameException.#ctor">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.NotSameException"/> class.
            </summary>
        </member>
        <member name="T:Should.Core.Exceptions.NullException">
            <summary>
            Exception thrown when an object reference is unexpectedly not null.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.NullException.#ctor(System.Object)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.NullException"/> class.
            </summary>
            <param name="actual"></param>
        </member>
        <member name="T:Should.Core.Exceptions.ParameterCountMismatchException">
            <summary>
            Exception to be thrown from <see cref="!:IMethodInfo.Invoke"/> when the number of
            parameter values does not the test method signature.
            </summary>
        </member>
        <member name="T:Should.Core.Exceptions.SameException">
            <summary>
            Exception thrown when two object references are unexpectedly not the same instance.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.SameException.#ctor(System.Object,System.Object)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.SameException"/> class.
            </summary>
            <param name="expected">The expected object reference</param>
            <param name="actual">The actual object reference</param>
        </member>
        <member name="T:Should.Core.Exceptions.SingleException">
            <summary>
            Exception thrown when the collection did not contain exactly one element.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.SingleException.#ctor(System.Int32)">
            <summary>
            Initializes a new instance of the <see cref="T:Should.Core.Exceptions.SingleException"/> class.
            </summary>
            <param name="count">The numbers of items in the collection.</param>
        </member>
        <member name="T:Should.Core.Exceptions.StartsWithException">
            <summary>
            Exception thrown when a collection unexpectedly does not contain the expected value.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.StartsWithException.#ctor(System.Object,System.Object)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.ContainsException"></see> class.
            </summary>
            <param name="expectedStartString">The expected object value</param>
            <param name="actual">The actual object value</param>
        </member>
        <member name="T:Should.Core.Exceptions.ThrowsException">
            <summary>
            Exception thrown when code unexpectedly fails to throw an exception.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.ThrowsException.#ctor(System.Type)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.ThrowsException"/> class. Call this constructor
            when no exception was thrown.
            </summary>
            <param name="expectedType">The type of the exception that was expected</param>
        </member>
        <member name="M:Should.Core.Exceptions.ThrowsException.#ctor(System.Type,System.Exception)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.ThrowsException"/> class. Call this constructor
            when an exception of the wrong type was thrown.
            </summary>
            <param name="expectedType">The type of the exception that was expected</param>
            <param name="actual">The actual exception that was thrown</param>
        </member>
        <member name="P:Should.Core.Exceptions.ThrowsException.StackTrace">
            <summary>
            Gets a string representation of the frames on the call stack at the time the current exception was thrown.
            </summary>
            <returns>A string that describes the contents of the call stack, with the most recent method call appearing first.</returns>
        </member>
        <member name="T:Should.Core.Exceptions.TimeoutException">
            <summary>
            Exception thrown when a test method exceeds the given timeout value
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.TimeoutException.#ctor(System.Int64)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.TimeoutException"/> class.
            </summary>
            <param name="timeout">The timeout value, in milliseconds</param>
        </member>
        <member name="T:Should.Core.Exceptions.TraceAssertException">
            <summary>
            Exception that is thrown when a call to Debug.Assert() fails.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.TraceAssertException.#ctor(System.String)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.TraceAssertException"/> class.
            </summary>
            <param name="assertMessage">The original assert message</param>
        </member>
        <member name="M:Should.Core.Exceptions.TraceAssertException.#ctor(System.String,System.String)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.TraceAssertException"/> class.
            </summary>
            <param name="assertMessage">The original assert message</param>
            <param name="assertDetailedMessage">The original assert detailed message</param>
        </member>
        <member name="P:Should.Core.Exceptions.TraceAssertException.AssertDetailedMessage">
            <summary>
            Gets the original assert detailed message.
            </summary>
        </member>
        <member name="P:Should.Core.Exceptions.TraceAssertException.AssertMessage">
            <summary>
            Gets the original assert message.
            </summary>
        </member>
        <member name="P:Should.Core.Exceptions.TraceAssertException.Message">
            <summary>
            Gets a message that describes the current exception.
            </summary>
        </member>
        <member name="T:Should.Core.Exceptions.TrueException">
            <summary>
            Exception thrown when a value is unexpectedly false.
            </summary>
        </member>
        <member name="M:Should.Core.Exceptions.TrueException.#ctor(System.String)">
            <summary>
            Creates a new instance of the <see cref="T:Should.Core.Exceptions.TrueException"/> class.
            </summary>
            <param name="userMessage">The user message to be displayed, or null for the default message</param>
        </member>
        <member name="T:Should.DateAssertionExtensions">
            <summary>
            Extensions which provide assertions to classes derived from <see cref="T:System.Boolean"/>.
            </summary>
        </member>
        <member name="M:Should.DateAssertionExtensions.ShouldEqual(System.DateTime,System.DateTime,System.TimeSpan)">
            <summary>
            Verifies that two values are equal within a given tolerance.
            </summary>
            <param name="actual">The value to be compared against</param>
            <param name="expected">The expected value</param>
            <param name="tolerance">The +/- value for where the expected and actual are considered to be equal</param>
            <exception cref="T:Should.Core.Exceptions.EqualException">Thrown when the objects are not equal</exception>
        </member>
        <member name="M:Should.DateAssertionExtensions.ShouldNotEqual(System.DateTime,System.DateTime,System.TimeSpan)">
            <summary>
            Verifies that two values are not equal within a given tolerance.
            </summary>
            <param name="actual">The value to be compared against</param>
            <param name="expected">The expected value</param>
            <param name="tolerance">The +/- value for where the expected and actual are considered to be equal</param>
            <exception cref="T:Should.Core.Exceptions.EqualException">Thrown when the objects are equal</exception>
        </member>
        <member name="M:Should.DateAssertionExtensions.ShouldEqual(System.DateTime,System.DateTime,Should.Core.DatePrecision)">
            <summary>
            Verifies that two values are equal within a given tolerance.
            </summary>
            <param name="actual">The value to be compared against</param>
            <param name="expected">The expected value</param>
            <param name="precision">The level of precision to use when making the comparison</param>
            <exception cref="T:Should.Core.Exceptions.EqualException">Thrown when the objects are not equal</exception>
        </member>
        <member name="M:Should.DateAssertionExtensions.ShouldNotEqual(System.DateTime,System.DateTime,Should.Core.DatePrecision)">
            <summary>
            Verifies that two values are not equal within a given tolerance.
            </summary>
            <param name="actual">The value to be compared against</param>
            <param name="expected">The expected value</param>
            <param name="precision">The level of precision to use when making the comparison</param>
            <exception cref="T:Should.Core.Exceptions.EqualException">Thrown when the objects are equal</exception>
        </member>
        <member name="T:Should.DoubleAssertionExtensions">
            <summary>
            Extensions which provide assertions to classes derived from <see cref="T:System.Boolean"/>.
            </summary>
        </member>
        <member name="M:Should.DoubleAssertionExtensions.ShouldEqual(System.Double,System.Double,System.Double)">
            <summary>
            Verifies that two values are equal within a given tolerance.
            </summary>
            <param name="actual">The value to be compared against</param>
            <param name="expected">The expected value</param>
            <param name="tolerance">The +/- value for where the expected and actual are considered to be equal</param>
            <exception cref="T:Should.Core.Exceptions.EqualException">Thrown when the objects are not equal</exception>
        </member>
        <member name="M:Should.DoubleAssertionExtensions.ShouldEqual(System.Double,System.Double,System.Double,System.String)">
            <summary>
            Verifies that two values are equal within a given tolerance.
            </summary>
            <param name="actual">The value to be compared against</param>
            <param name="expected">The expected value</param>
            <param name="tolerance">The +/- value for where the expected and actual are considered to be equal</param>
            <param name="message">The user message to show on failure</param>
            <exception cref="T:Should.Core.Exceptions.EqualException">Thrown when the objects are not equal</exception>
        </member>
        <member name="M:Should.DoubleAssertionExtensions.ShouldNotEqual(System.Double,System.Double,System.Double)">
            <summary>
            Verifies that two values are not equal within a given tolerance.
            </summary>
            <param name="actual">The value to be compared against</param>
            <param name="expected">The expected value</param>
            <param name="tolerance">The +/- value for where the expected and actual are considered to be equal</param>
            <exception cref="T:Should.Core.Exceptions.EqualException">Thrown when the objects are equal</exception>
        </member>
        <member name="M:Should.DoubleAssertionExtensions.ShouldNotEqual(System.Double,System.Double,System.Double,System.String)">
            <summary>
            Verifies that two values are not equal within a given tolerance.
            </summary>
            <param name="actual">The value to be compared against</param>
            <param name="expected">The expected value</param>
            <param name="tolerance">The +/- value for where the expected and actual are considered to be equal</param>
            <param name="message">The user message to show on failure</param>
            <exception cref="T:Should.Core.Exceptions.EqualException">Thrown when the objects are equal</exception>
        </member>
        <member name="T:Should.ObjectAssertExtensions">
            <summary>
            Extensions which provide assertions to classes derived from <see cref="T:System.Object"/>.
            </summary>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldBeGreaterThan``1(``0,``0)">
            <summary>Verifies that an object is greater than the exclusive minimum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="object">The object to be evaluated (left side of the comparison).</param>
            <param name="value">The (exclusive) minimum value of the <paramref name="object"/>. (The right side of the comparison.)</param>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldBeGreaterThan``1(``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>Verifies that an object is greater than the exclusive minimum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="object">The object to be evaluated (left side of the comparison).</param>
            <param name="value">The (exclusive) minimum value of the <paramref name="object"/>. (The right side of the comparison.)</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> used to compare the objects.</param>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldBeGreaterThanOrEqualTo``1(``0,``0)">
            <summary>Verifies that an object is greater than the inclusive minimum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="object">The object to be evaluated (left side of the comparison).</param>
            <param name="value">The (inclusive) minimum value of the <paramref name="object"/>. (The right side of the comparison.)</param>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldBeGreaterThanOrEqualTo``1(``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>Verifies that an object is greater than the inclusive minimum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="object">The object to be evaluated (left side of the comparison).</param>
            <param name="value">The (inclusive) minimum value of the <paramref name="object"/>. (The right side of the comparison.)</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> used to compare the objects.</param>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldBeInRange``1(``0,``0,``0)">
            <summary>
            Verifies that a value is within a given range.
            </summary>
            <typeparam name="T">The type of the value to be compared</typeparam>
            <param name="actual">The actual value to be evaluated</param>
            <param name="low">The (inclusive) low value of the range</param>
            <param name="high">The (inclusive) high value of the range</param>
            <exception cref="T:Should.Core.Exceptions.InRangeException">Thrown when the value is not in the given range</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldBeInRange``1(``0,``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>
            Verifies that a value is within a given range, using a comparer.
            </summary>
            <typeparam name="T">The type of the value to be compared</typeparam>
            <param name="actual">The actual value to be evaluated</param>
            <param name="low">The (inclusive) low value of the range</param>
            <param name="high">The (inclusive) high value of the range</param>
            <param name="comparer">The comparer used to evaluate the value's range</param>
            <exception cref="T:Should.Core.Exceptions.InRangeException">Thrown when the value is not in the given range</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldBeLessThan``1(``0,``0)">
            <summary>Verifies that an object is less than the exclusive maximum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="object">The object to be evaluated (left side of the comparison).</param>
            <param name="value">The (exclusive) maximum value of the <paramref name="object"/>. (The right side of the comparison.)</param>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldBeLessThan``1(``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>Verifies that an object is less than the exclusive maximum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="object">The object to be evaluated (left side of the comparison).</param>
            <param name="value">The (exclusive) maximum value of the <paramref name="object"/>. (The right side of the comparison.)</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> used to compare the objects.</param>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldBeLessThanOrEqualTo``1(``0,``0)">
            <summary>Verifies that an object is less than the inclusive maximum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="object">The object to be evaluated (left side of the comparison).</param>
            <param name="value">The (inclusive) maximum value of the <paramref name="object"/>. (The right side of the comparison.)</param>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldBeLessThanOrEqualTo``1(``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>Verifies that an object is less than the inclusive maximum value.</summary>
            <typeparam name="T">The type of the objects to be compared.</typeparam>
            <param name="object">The object to be evaluated (left side of the comparison).</param>
            <param name="value">The (inclusive) maximum value of the <paramref name="object"/>. (The right side of the comparison.)</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> used to compare the objects.</param>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldBeNull(System.Object)">
            <summary>
            Verifies that an object reference is null.
            </summary>
            <param name="object">The object to be inspected</param>
            <exception cref="T:Should.Core.Exceptions.NullException">Thrown when the object reference is not null</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldBeSameAs(System.Object,System.Object)">
            <summary>
            Verifies that two objects are the same instance.
            </summary>
            <param name="actual">The actual object instance</param>
            <param name="expected">The expected object instance</param>
            <exception cref="T:Should.Core.Exceptions.SameException">Thrown when the objects are not the same instance</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldBeType``1(System.Object)">
            <summary>
            Verifies that an object is exactly the given type (and not a derived type).
            </summary>
            <typeparam name="T">The type the object should be</typeparam>
            <param name="object">The object to be evaluated</param>
            <returns>The object, casted to type T when successful</returns>
            <exception cref="T:Should.Core.Exceptions.IsTypeException">Thrown when the object is not the given type</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldBeType(System.Object,System.Type)">
            <summary>
            Verifies that an object is exactly the given type (and not a derived type).
            </summary>
            <param name="object">The object to be evaluated</param>
            <param name="expectedType">The type the object should be</param>
            <exception cref="T:Should.Core.Exceptions.IsTypeException">Thrown when the object is not the given type</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldImplement``1(System.Object)">
            <summary>
            Verifies that an object is of the given type or a derived type
            </summary>
            <typeparam name="T">The type the object should implement</typeparam>
            <param name="object">The object to be evaluated</param>
            <returns>The object, casted to type T when successful</returns>
            <exception cref="T:Should.Core.Exceptions.IsTypeException">Thrown when the object is not the given type</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldImplement(System.Object,System.Type)">
            <summary>
            Verifies that an object is of the given type or a derived type
            </summary>
            <param name="object">The object to be evaluated</param>
            <param name="expectedType">The type the object should implement</param>
            <exception cref="T:Should.Core.Exceptions.IsTypeException">Thrown when the object is not the given type</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldImplement``1(System.Object,System.String)">
            <summary>
            Verifies that an object is of the given type or a derived type
            </summary>
            <typeparam name="T">The type the object should implement</typeparam>
            <param name="object">The object to be evaluated</param>
            <param name="message">The user message to show on failure</param>
            <returns>The object, casted to type T when successful</returns>
            <exception cref="T:Should.Core.Exceptions.IsTypeException">Thrown when the object is not the given type</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldImplement(System.Object,System.Type,System.String)">
            <summary>
            Verifies that an object is of the given type or a derived type
            </summary>
            <param name="object">The object to be evaluated</param>
            <param name="expectedType">The type the object should implement</param>
            <param name="message">The user message to show on failure</param>
            <exception cref="T:Should.Core.Exceptions.IsTypeException">Thrown when the object is not the given type</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldEqual``1(``0,``0)">
            <summary>
            Verifies that two objects are equal, using a default comparer.
            </summary>
            <typeparam name="T">The type of the objects to be compared</typeparam>
            <param name="actual">The value to be compared against</param>
            <param name="expected">The expected value</param>
            <exception cref="T:Should.Core.Exceptions.EqualException">Thrown when the objects are not equal</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldEqual``1(``0,``0,System.String)">
            <summary>
            Verifies that two objects are equal, using a default comparer, with a custom error message
            </summary>
            <typeparam name="T">The type of the objects to be compared</typeparam>
            <param name="actual">The value to be compared against</param>
            <param name="expected">The expected value</param>
            <param name="message">The user message to show on failure</param>
            <exception cref="T:Should.Core.Exceptions.EqualException">Thrown when the objects are not equal</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldEqual``1(``0,``0,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Verifies that two objects are equal, using a custom comparer.
            </summary>
            <typeparam name="T">The type of the objects to be compared</typeparam>
            <param name="actual">The value to be compared against</param>
            <param name="expected">The expected value</param>
            <param name="comparer">The comparer used to compare the two objects</param>
            <exception cref="T:Should.Core.Exceptions.EqualException">Thrown when the objects are not equal</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldNotBeInRange``1(``0,``0,``0)">
            <summary>
            Verifies that a value is not within a given range, using the default comparer.
            </summary>
            <typeparam name="T">The type of the value to be compared</typeparam>
            <param name="actual">The actual value to be evaluated</param>
            <param name="low">The (inclusive) low value of the range</param>
            <param name="high">The (inclusive) high value of the range</param>
            <exception cref="T:Should.Core.Exceptions.NotInRangeException">Thrown when the value is in the given range</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldNotBeInRange``1(``0,``0,``0,System.Collections.Generic.IComparer{``0})">
            <summary>
            Verifies that a value is not within a given range, using a comparer.
            </summary>
            <typeparam name="T">The type of the value to be compared</typeparam>
            <param name="actual">The actual value to be evaluated</param>
            <param name="low">The (inclusive) low value of the range</param>
            <param name="high">The (inclusive) high value of the range</param>
            <param name="comparer">The comparer used to evaluate the value's range</param>
            <exception cref="T:Should.Core.Exceptions.NotInRangeException">Thrown when the value is in the given range</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldNotBeNull``1(``0)">
            <summary>
            Verifies that an object reference is not null.
            </summary>
            <param name="object">The object to be validated</param>
            <exception cref="T:Should.Core.Exceptions.NotNullException">Thrown when the object is not null</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldNotBeNull``1(``0,System.String)">
            <summary>
            Verifies that an object reference is not null.
            </summary>
            <param name="object">The object to be validated</param>
            <param name="message">The message to show on failure</param>
            <exception cref="T:Should.Core.Exceptions.NotNullException">Thrown when the object reference is null</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldNotBeSameAs(System.Object,System.Object)">
            <summary>
            Verifies that two objects are not the same instance.
            </summary>
            <param name="actual">The actual object instance</param>
            <param name="expected">The expected object instance</param>
            <exception cref="T:Should.Core.Exceptions.NotSameException">Thrown when the objects are the same instance</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldNotBeType``1(System.Object)">
            <summary>
            Verifies that an object is not exactly the given type.
            </summary>
            <typeparam name="T">The type the object should not be</typeparam>
            <param name="object">The object to be evaluated</param>
            <exception cref="T:Should.Core.Exceptions.IsTypeException">Thrown when the object is the given type</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldNotBeType(System.Object,System.Type)">
            <summary>
            Verifies that an object is not exactly the given type.
            </summary>
            <param name="object">The object to be evaluated</param>
            <param name="expectedType">The type the object should not be</param>
            <exception cref="T:Should.Core.Exceptions.IsTypeException">Thrown when the object is the given type</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldNotEqual``1(``0,``0)">
            <summary>
            Verifies that two objects are not equal, using a default comparer.
            </summary>
            <typeparam name="T">The type of the objects to be compared</typeparam>
            <param name="actual">The actual object</param>
            <param name="expected">The expected object</param>
            <exception cref="T:Should.Core.Exceptions.NotEqualException">Thrown when the objects are equal</exception>
        </member>
        <member name="M:Should.ObjectAssertExtensions.ShouldNotEqual``1(``0,``0,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Verifies that two objects are not equal, using a custom comparer.
            </summary>
            <typeparam name="T">The type of the objects to be compared</typeparam>
            <param name="actual">The actual object</param>
            <param name="expected">The expected object</param>
            <param name="comparer">The comparer used to examine the objects</param>
            <exception cref="T:Should.Core.Exceptions.NotEqualException">Thrown when the objects are equal</exception>
        </member>
        <member name="T:Should.StringAssertionExtensions">
            <summary>
            Extensions which provide assertions to classes derived from <see cref="T:System.String"/>.
            </summary>
        </member>
        <member name="M:Should.StringAssertionExtensions.ShouldContain(System.String,System.String)">
            <summary>
            Verifies that a string contains a given sub-string, using the current culture.
            </summary>
            <param name="actualString">The string to be inspected</param>
            <param name="expectedSubString">The sub-string expected to be in the string</param>
            <exception cref="T:Should.Core.Exceptions.ContainsException">Thrown when the sub-string is not present inside the string</exception>
        </member>
        <member name="M:Should.StringAssertionExtensions.ShouldContain(System.String,System.String,System.StringComparison)">
            <summary>
            Verifies that a string contains a given sub-string, using the given comparison type.
            </summary>
            <param name="actualString">The string to be inspected</param>
            <param name="expectedSubString">The sub-string expected to be in the string</param>
            <param name="comparisonType">The type of string comparison to perform</param>
            <exception cref="T:Should.Core.Exceptions.ContainsException">Thrown when the sub-string is not present inside the string</exception>
        </member>
        <member name="M:Should.StringAssertionExtensions.ShouldNotContain(System.String,System.String)">
            <summary>
            Verifies that a string does not contain a given sub-string, using the current culture.
            </summary>
            <param name="actualString">The string to be inspected</param>
            <param name="expectedSubString">The sub-string which is expected not to be in the string</param>
            <exception cref="T:Should.Core.Exceptions.DoesNotContainException">Thrown when the sub-string is present inside the string</exception>
        </member>
        <member name="M:Should.StringAssertionExtensions.ShouldNotContain(System.String,System.String,System.StringComparison)">
            <summary>
            Verifies that a string does not contain a given sub-string, using the current culture.
            </summary>
            <param name="actualString">The string to be inspected</param>
            <param name="expectedSubString">The sub-string which is expected not to be in the string</param>
            <param name="comparisonType">The type of string comparison to perform</param>
            <exception cref="T:Should.Core.Exceptions.DoesNotContainException">Thrown when the sub-string is present inside the given string</exception>
        </member>
    </members>
</doc>
